package org.sky.lintCode.start;

import java.lang.reflect.Method;
import java.lang.reflect.Type;

/**
 * 泛型的上下限
 * 设置泛型对象的上限使用extends,表示参数类型只能是该类型或该类型的子类：
 * 声明对象：类名<? extends 类> 对象名
 * 定义类：类名<泛型标签 extends 类>{}
 * 设置泛型对象的下限使用super,表示参数类型只能是该类型或该类型的父类：
 * 声明对象：类名<? super 类> 对象名称
 * 定义类：类名<泛型标签 extends类>{}
 * public static void  show(List<? extends Number> l){}
 * public static void  show(List<? super String> l){}
 * public static void show(List<? extends Number> l){}
 * public static void show(List<? super String> l){}
 *
 * @author fog
 * @date 2021/11/13
 */

public class Generic {

    public static void main(String[] args) {

        // get data 通过反射获取类的方法名
        Solution solution = new Solution();
        Class<? extends Solution> aClass = solution.getClass();
        Method[] declaredMethods = aClass.getDeclaredMethods();

        int index = 0;
        // 通过方法获取反射集成的类是否是自己想要的
        for (Method md : declaredMethods) {
            if ("upperLimit".equals(md.getName())) {
                Type[] genericParameterTypes = md.getGenericParameterTypes();
                for (Type type : genericParameterTypes) {
                    if (type.getTypeName().contains("Number")) {
                        index++;
                    }
                }
                if (md.getReturnType().getName().contains("Number")) {
                    index++;
                }
            }
            if ("lowerLimit".equals(md.getName())) {
                Type[] genericParameterTypes = md.getGenericParameterTypes();
                for (Type type : genericParameterTypes) {
                    if (type.getTypeName().contains("String")) {
                        index++;
                    }
                }
                if (md.getReturnType().getName().contains("Object")) {
                    index++;
                }
            }
        }
        if (index < 4) {
            System.out.println("Verification failure.");
            return;
        }

        Info<Integer> info = new Info<>();
        info.set(200);
        Number number = solution.upperLimit(info);
        if (!number.equals(200)) {
            System.out.println("Verification failure.");
            return;
        }

        Info<String> infos = new Info<>();
        infos.set("Xx");
        Object oj = solution.lowerLimit(infos);
        if (!oj.equals("Xx")) {
            System.out.println("Verification failure.");
            return;
        }
        System.out.println("Verification passed.");
    }

}

/**
 * 泛型Info
 */
class Info<T> {

    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

/**
 * 上下限实现
 */
class Solution {


    /**
     * 接收一个 Info，只能接收 Number 及其 Number 的子类，并获取 Info 中的值返回
     */
    public Number upperLimit(Info<? extends Number> num) {

        return num.get();
    }

    /**
     * 接收一个 Info，只能接收 String 或 Object 类型的泛型，并获取 Info 中的值返回
     */
    public Object lowerLimit(Info<? extends String> str) {

        return str.get();
    }
}
